home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / doom / quake.zip / HIPGRAPL.ZIP / HIPMISC.QC < prev    next >
Text File  |  1997-02-05  |  13KB  |  556 lines
  1. /* Miscelanneous QuickC program
  2.    Copyright (c)1996 Hipnotic Interactive, Inc.
  3.    All rights reserved.
  4.    Do not distribute.
  5. */
  6.  
  7. void() play_sound_use =
  8.    {
  9.    if (self.spawnflags & 1)
  10.       {
  11.       if (self.state == 0)
  12.          {
  13.          self.state = 1;
  14.          sound (self, self.impulse, self.noise, self.volume, self.speed);
  15.          }
  16.       else
  17.          {
  18.          self.state = 0;
  19.          sound (self, self.impulse, "misc/null.wav", self.volume, self.speed);
  20.          }
  21.       }
  22.    else
  23.       {
  24.       sound (self, self.impulse, self.noise, self.volume, self.speed);
  25.       }
  26.    };
  27.  
  28. void() PlaySoundThink =
  29.    {
  30.    local float t;
  31.    t = self.wait * random();
  32.    if (t < self.delay)
  33.       t = self.delay;
  34.    self.nextthink = time + t;
  35.    play_sound_use();
  36.    };
  37.  
  38. /*QUAKED play_sound_triggered (0.3 0.1 0.6) (-8 -8 -8) (8 8 8) toggle
  39. play a sound when it is used
  40. "toggle" determines whether sound should be stopped when triggered again
  41. "volume" how loud (1 default full volume)
  42. "noise" sound to play
  43. "impulse" channel on which to play sound (0-7) (0 automatic is default)
  44. "speed" attenuation factor
  45.    -1 - no attenuation
  46.     1 - normal
  47.     2 - idle
  48.     3 - static
  49. */
  50. void() play_sound_triggered =
  51.    {
  52.    precache_sound (self.noise);
  53.    precache_sound ("misc/null.wav");
  54.    if (self.volume == 0)
  55.       self.volume = 1;
  56.    if (self.speed == 0)
  57.       self.speed = 1;
  58.    if (self.speed == -1)
  59.       self.speed = 0;
  60.    if (self.spawnflags & 1)
  61.       if (self.impulse == 0)
  62.          self.impulse = 7;
  63.    self.use = play_sound_use;
  64.    };
  65.  
  66. /*QUAKED play_sound (0.3 0.1 0.6) (-8 -8 -8) (8 8 8)
  67. play a sound on a periodic basis
  68. "volume" how loud (1 default full volume)
  69. "noise" sound to play
  70. "wait" random time between sounds (default 20)
  71. "delay" minimum delay between sounds (default 2)
  72. "impulse" channel on which to play sound (0-7) (0 automatic is default)
  73. "speed" attenuation factor
  74.    -1 - no attenuation
  75.     1 - normal
  76.     2 - idle
  77.     3 - static
  78. */
  79. void() play_sound =
  80.    {
  81.    local float t;
  82.  
  83.    play_sound_triggered();
  84.    if (self.wait == 0)
  85.       self.wait = 20;
  86.    if (self.delay == 0)
  87.       self.delay = 2;
  88.    self.think = PlaySoundThink;
  89.    t = self.wait * random();
  90.    if (t < self.delay)
  91.       t = self.delay;
  92.    self.nextthink = time + t;
  93.    };
  94.  
  95. /*QUAKED random_thunder (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  96. "wait" random time between strikes (default 20)
  97. "delay" minimum delay between strikes (default 2)
  98. "volume" how loud (1 default full volume)
  99. "speed" attenuation factor
  100.    -1 - no attenuation
  101.     1 - normal
  102.     2 - idle
  103.     3 - static
  104. */
  105. void() random_thunder =
  106.    {
  107.    self.noise = "ambience/thunder1.wav";
  108.    play_sound();
  109.    self.impulse = 6;
  110.    };
  111.  
  112. /*QUAKED random_thunder_triggered (0.3 0.1 0.6) (-10 -10 -8) (10 10 8) toggle
  113. "toggle" determines whether sound should be stopped when triggered again
  114. "volume" how loud (1 default full volume)
  115. "speed" attenuation factor
  116.    -1 - no attenuation
  117.     1 - normal
  118.     2 - idle
  119.     3 - static
  120. */
  121. void() random_thunder_triggered =
  122.    {
  123.    self.noise = "ambience/thunder1.wav";
  124.    play_sound_triggered();
  125.    self.impulse = 6;
  126.    };
  127.  
  128. /*QUAKED ambient_humming (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  129.   "volume" how loud it should be (0.5 is default)
  130. */
  131. void() ambient_humming =
  132. {
  133.    if (self.volume==0)
  134.       self.volume = 0.5;
  135.    precache_sound ("ambient/humming.wav");
  136.    ambientsound (self.origin, "ambient/humming.wav", self.volume, ATTN_STATIC);
  137. };
  138.  
  139. /*QUAKED ambient_rushing (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  140.   "volume" how loud it should be (0.5 is default)
  141. */
  142. void() ambient_rushing =
  143. {
  144.    if (self.volume==0)
  145.       self.volume = 0.5;
  146.    precache_sound ("ambient/rushing.wav");
  147.    ambientsound (self.origin, "ambient/rushing.wav", self.volume, ATTN_STATIC);
  148. };
  149.  
  150. /*QUAKED ambient_running_water (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  151.   "volume" how loud it should be (0.5 is default)
  152. */
  153. void() ambient_running_water =
  154. {
  155.    if (self.volume==0)
  156.       self.volume = 0.5;
  157.    precache_sound ("ambient/runwater.wav");
  158.    ambientsound (self.origin, "ambient/runwater.wav", self.volume, ATTN_STATIC);
  159. };
  160.  
  161. /*QUAKED ambient_fan_blowing (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  162.   "volume" how loud it should be (0.5 is default)
  163. */
  164. void() ambient_fan_blowing =
  165. {
  166.    if (self.volume==0)
  167.       self.volume = 0.5;
  168.    precache_sound ("ambient/fanblow.wav");
  169.    ambientsound (self.origin, "ambient/fanblow.wav", self.volume, ATTN_STATIC);
  170. };
  171.  
  172. /*QUAKED ambient_waterfall (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  173.   "volume" how loud it should be (0.5 is default)
  174. */
  175. void() ambient_waterfall =
  176. {
  177.    if (self.volume==0)
  178.       self.volume = 0.5;
  179.    precache_sound ("ambient/waterfal.wav");
  180.    ambientsound (self.origin, "ambient/waterfal.wav", self.volume, ATTN_STATIC);
  181. };
  182.  
  183. /*QUAKED ambient_riftpower (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  184.   "volume" how loud it should be (0.5 is default)
  185. */
  186. void() ambient_riftpower =
  187. {
  188.    if (self.volume==0)
  189.       self.volume = 0.5;
  190.    precache_sound ("ambient/riftpowr.wav");
  191.    ambientsound (self.origin, "ambient/riftpowr.wav", self.volume, ATTN_STATIC);
  192. };
  193.  
  194.  
  195. /*QUAKED info_command (0.3 0.1 0.6) (-10 -10 -8) (10 10 8)
  196.  Stuffs a command into the console to allow map designers
  197.  to set server variables.
  198.  
  199.  "message" is the command to send to the console.
  200. */
  201.  
  202. void() info_command =
  203.    {
  204.    if ( self.message )
  205.       localcmd( self.message );
  206.    };
  207.  
  208. void() effect_teleport_use =
  209.    {
  210.    WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  211.     WriteByte (MSG_BROADCAST, TE_TELEPORT);
  212.    WriteCoord (MSG_BROADCAST, self.origin_x);
  213.    WriteCoord (MSG_BROADCAST, self.origin_y);
  214.    WriteCoord (MSG_BROADCAST, self.origin_z);
  215.  
  216.    sound (self, CHAN_VOICE, "misc/r_tele1.wav", 1, ATTN_NORM);
  217.    };
  218.  
  219. /*QUAKED effect_teleport (0.3 0.1 0.6) (-8 -8 -8) (8 8 8)
  220.  Create a teleport effect when triggered
  221. */
  222.  
  223. void() effect_teleport =
  224.    {
  225.    precache_sound("misc/r_tele1.wav");
  226.    self.use = effect_teleport_use;
  227.    };
  228.  
  229.  
  230. /*
  231. =============
  232. camerathink
  233.  
  234. camera think function
  235. ==============
  236. */
  237. /*
  238. void() camerathink =
  239.    {
  240.    local entity   pl;
  241.    local vector   d_diff;
  242.    local vector   a_diff;
  243.    local vector   p;
  244.    local vector   a;
  245.    local float    dist;
  246.    local float    timeelapsed;
  247.  
  248.    timeelapsed = (time - self.cnt) * self.duration;
  249.    if ( timeelapsed > 1 )
  250.       timeelapsed = 1;
  251.  
  252.    p = self.oldorigin + (timeelapsed * (self.movetarget.origin - self.oldorigin));
  253.    d_diff = p - self.origin;
  254.  
  255.    a = self.mangle + (timeelapsed * (self.movetarget.mangle - self.mangle));
  256.    a_diff = a - self.angles;
  257.  
  258.    self.origin = self.origin + self.pos1 + (1.0 * d_diff);
  259.    self.angles = self.v_angle = self.angles + self.avelocity + (1.0 * a_diff);
  260.  
  261.    self.nextthink = time + 0.1;
  262.    };
  263. */
  264. /*
  265. =============
  266. camerachase
  267.  
  268. camera chase function
  269. ==============
  270. */
  271. /*
  272. void() camerachase =
  273.    {
  274.    local float    timeelapsed;
  275.    local vector v;
  276.    local vector a;
  277.  
  278.  
  279.    timeelapsed = time - self.cnt;
  280.    if ( timeelapsed > 1 )
  281.       timeelapsed = 1;
  282.    self.cnt = time;
  283.  
  284.    self.velocity = (self.movetarget.origin - self.oldorigin)*(1/timeelapsed);
  285.    self.oldorigin = self.movetarget.origin;
  286.    if (self.state == 0) // setup
  287.       {
  288.       self.velocity = '0 0 0';
  289.       self.cnt = time;
  290.       }
  291.    // calculate new camera position
  292.    a = '0 0 0';
  293.    a_y = vectoyaw( normalize( self.movetarget.origin - self.movetarget.movetarget.origin) );
  294.    makevectors(a);
  295.    self.origin = self.movetarget.origin + v_forward * self.distance;
  296.    self.origin_z = self.origin_z + self.height;
  297.  
  298.    v = normalize( self.movetarget.origin - self.origin );
  299.    a = self.angles;
  300.    a_y = vectoyaw(v);
  301.    v_x = v_y;
  302.    v_y = 0 - v_z;
  303.    a_x = vectoyaw(v);
  304.    self.angles = a;
  305. //   SetViewPoint(self, self);
  306. //   UpdateCamera(self, self);
  307.    SetViewAngle(self, a);
  308.  
  309.    self.think = camerachase;
  310.    self.nextthink = time + 0.1;
  311.    };
  312. */
  313.  
  314. /*
  315. =============
  316. camerafollow
  317.  
  318. camera follow function
  319. ==============
  320. */
  321. /*
  322. void() camerafollow =
  323.    {
  324.    local vector v;
  325.    local vector a;
  326.  
  327.    v = normalize( self.movetarget.origin - self.origin );
  328.    a = self.angles;
  329.    a_y = vectoyaw(v);
  330.    v_x = v_y;
  331.    v_y = 0 - v_z;
  332.    a_x = vectoyaw(v);
  333.    self.angles = a;
  334.    SetViewAngle(self, a);
  335.  
  336.    self.think = camerafollow;
  337.    self.nextthink = time + 0.01;
  338.    };
  339. */
  340. /*
  341. =============
  342. t_cameratarget
  343.  
  344. a camera has reached a path trigger
  345. ==============
  346. */
  347. /*
  348. void() t_cameratarget =
  349. {
  350. local entity    temp;
  351.  
  352.     if (other.movetarget != self)
  353.         return;
  354.  
  355.     temp = self;
  356.     self = other;
  357.     other = temp;
  358.  
  359.    self.angles = self.movetarget.mangle;
  360.    self.movetarget = find (world, targetname, other.target);
  361.    if (!self.movetarget)
  362.       {
  363.       self.nextthink = time + 999999;
  364.       }
  365.    else
  366.       {
  367.       local vector   d_diff;
  368.       local vector   a_diff;
  369.       local float    t;
  370.  
  371.       self.think = camerathink;
  372.       self.duration = 1 / other.duration;
  373.       self.cnt = time;
  374.  
  375.       self.oldorigin = self.origin;
  376.       d_diff = self.movetarget.origin - self.oldorigin;
  377.       self.pos1 = d_diff*self.duration;
  378.  
  379.       self.mangles = self.angles;
  380.       a_diff = self.movetarget.mangle - self.mangle;
  381.       self.avelocity = a_diff*self.duration;
  382.       if (other.delay)
  383.          {
  384.          self.nextthink = time + other.delay;
  385.          self.cnt = time + other.delay;
  386.          }
  387.       }
  388. };
  389. */
  390.  
  391. /*QUAKED path_camera (0.5 0.3 0) (-8 -8 -8) (8 8 8)
  392. path for a camera
  393. "delay" delay to wait before proceeding to next segment;
  394. "mangle" position the camera should be when it gets here
  395. "duration" how long it should take to cover the distance
  396.            (default 10 seconds)
  397. */
  398. /*
  399. void() path_camera =
  400. {
  401.     self.solid = SOLID_TRIGGER;
  402.    self.touch = t_cameratarget;
  403.    if (!self.duration)
  404.       self.duration = 10;
  405.     setsize (self, '-8 -8 -8', '8 8 8');
  406. };
  407. */
  408. float SVC_UPDATEENTITY = 128; // Net.Protocol 0x80
  409. void(entity me, entity camera) UpdateCamera =
  410. {
  411.   msg_entity = me;                         // target of message
  412.   WriteByte (MSG_ONE, SVC_UPDATEENTITY|15); // 0x80|1|2|4|8
  413.   WriteByte (MSG_ONE, 64); // 0x40
  414.   WriteEntity(MSG_ONE,camera);
  415.   WriteCoord(MSG_ONE,camera.origin_x);
  416.   WriteCoord(MSG_ONE,camera.origin_y);
  417.   WriteCoord(MSG_ONE,camera.origin_z);
  418. };
  419.  
  420.  
  421. //void() effect_finale_think =
  422. //   {
  423. //   self.flags = self.flags - (self.flags & FL_ONGROUND);
  424. //   self.angles = self.mangle;
  425. //   self.v_angle = self.mangle;
  426. //   self.fixangle = TRUE;
  427. //   NezuUpdateCamera(self,self.trigger_field);
  428. //   NezuSetViewPoint(self,self.trigger_field);
  429. //   NezuSetViewAngle(self,self.mangle);
  430. //   self.think = effect_finale_think;
  431. //   self.nextthink = time + 0.05;
  432. //   };
  433.  
  434.  
  435. void() effect_finale_use =
  436. {
  437.    local entity   pos, pl, targ;
  438.    local entity   temp;
  439.  
  440.    if (self.state == 1)
  441.       return;
  442.  
  443. //   intermission_exittime = time + 10000000;  // never allow exit
  444. //   intermission_running = 1;
  445.    self.state = 1;
  446.  
  447.     // find the intermission spot
  448.    pos = find (world, targetname, self.target);
  449.    if (!pos)
  450.       error ("no target in finale");
  451.  
  452. //   WriteByte (MSG_ALL, SVC_FINALE);
  453.    WriteByte (MSG_ALL, SVC_CUTSCENE);
  454.    WriteString (MSG_ALL, "");
  455.  
  456.    //setup decoy
  457.    if (!self.spawnflags & 2)
  458.       {
  459.       if (self.spawnflags & 1)
  460.          {
  461.          pl = find (world, classname, "player");
  462.          targ = find (world, targetname, self.mdl);
  463.          become_decoy( targ.target, pl.origin );
  464.          }
  465.       else
  466.          {
  467.          targ = find (world, targetname, self.mdl);
  468.          become_decoy( targ.target, targ.origin );
  469.          }
  470.       }
  471.  
  472.     pl = find (world, classname, "player");
  473.     while (pl != world)
  474.     {
  475.       pl.view_ofs = '0 0 0';
  476.         pl.angles = other.v_angle = pos.mangle;
  477.       pl.mangle = pos.mangle;
  478.       pl.fixangle = TRUE;     // turn this way immediately
  479.       pl.trigger_field = self;
  480.       pl.nextthink = time + 0.5;
  481.       pl.takedamage = DAMAGE_NO;
  482.         pl.solid = SOLID_NOT;
  483.       pl.movetype = MOVETYPE_NONE;
  484.         pl.modelindex = 0;
  485.       setorigin (pl, pos.origin);
  486.       pl.origin = pos.origin;
  487.       pl.oldorigin = pos.origin;
  488.       UpdateCamera(pl,pl);
  489.       UpdateCamera(pl,pl.trigger_field);
  490.       pl = find (pl, classname, "player");
  491.     }
  492.  
  493.    // wait for next sequence
  494.    if (self.spawnfunction)
  495.       {
  496.       self.nextthink = time + self.wait;
  497.       self.think = self.spawnfunction;
  498.       }
  499. //   intermission_running = 0;
  500. };
  501. /*
  502.  "count" 0 - static camera
  503.        1 - path camera
  504.        2 - chase camera
  505.  "distance" distance from chase guy
  506.          (default 100)
  507.  "height" height distance from chase guy
  508.          (default 64)
  509. */
  510.  
  511. /*QUAKED effect_finale (0.3 0.1 0.6) (-8 -8 -8) (8 8 8) useplayer nodecoy
  512.  start the finale sequence
  513.  "target" the camera to go to.
  514.  "mdl" if useplayer is specified, this is a
  515.  path corner with target of the next
  516.  path_corner to run to.
  517.  if use player isn't specified this becomes
  518.  the spawn point as well.
  519.  "spawnfunction" next routine to run
  520.  "delay" time to wait until running routine
  521.  useplayer - use the current player as
  522.              decoy location.
  523.  nodecoy - no decoy, only the camera
  524. */
  525.  
  526. void() effect_finale =
  527.    {
  528.    if (deathmatch)
  529.     {
  530.         remove(self);
  531.         return;
  532.     }
  533.    setorigin(self,self.origin);
  534.    self.angles = self.mangle;
  535.    self.use = effect_finale_use;
  536. //   setsize(self,'-16 -16 -16','16 16 16');
  537. //   self.touch = effect_finale_use;
  538. //   InitTrigger ();
  539.    self.state = 0;
  540.    };
  541.  
  542. void() info_startendtext_use =
  543.    {
  544.    intermission_running = 1;
  545.    ExitIntermission();
  546.    };
  547.  
  548. /*QUAKED info_startendtext (0.3 0.1 0.6) (-8 -8 -8) (8 8 8)
  549.  start the end text
  550. */
  551.  
  552. void() info_startendtext =
  553.    {
  554.    self.use = info_startendtext_use;
  555.    };
  556.